/*-------------------------------------------------------------------------
   io3731.h - Define all the registers on the IO3731

   Copyright (C) 2010 One Laptop per Child

   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by the
   Free Software Foundation; either version 2, or (at your option) any
   later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

   In other words, you are welcome to use, share and improve this program.
   You are forbidden to forbid anyone else to use, share and improve
   what you give them.   Help stamp out software-hoarding!

   As a special exception, you may use this file as part of a free software
   library for the XO of the One Laptop per Child project without restriction.
   Specifically, if other files instantiate
   templates or use macros or inline functions from this file, or you compile
   this file and link it with other files to produce an executable, this
   file does not by itself cause the resulting executable to be covered by
   the GNU General Public License.  This exception does not however
   invalidate any other reasons why the executable file might be covered by
   the GNU General Public License.
-------------------------------------------------------------------------*/

#ifndef IO3731_H
#define IO3731_H

#include "cc_compat.h"

// Location of the ec tags area
#define EC_TAG_CP	0
#define EC_TAG_AP	1
#define EC_TAG_PWRLIMIT 2

EXTERN unsigned char code  ABS_ADDR(ec_tags[0x80],0x7e80);

#define AUTO_PWR_FLAG  1
#define CONST_PWR_FLAG 2

EXTERN unsigned char xdata BootFlags;

// Misc Registers
ABS_SFRX( SMB_INTC, 0xf001);	// SMBus Internal Connection
ABS_SFRX( SMB_PC, 0xf002);		// SMBus Port Connection
ABS_SFRX( SMBD_PC, 0xf003);		// SMBus Device Controller Port Connection
ABS_SFRX( E51_STA, 0xf005);		// 8051 Status
ABS_SFRX( PMUCFG, 0xf00a);		// PMU Control / Configuration
ABS_SFRX( CLKCFG, 0xf00b);		// Clock Configuration
ABS_SFRX( DAC0, 0xf00c);		// DAC0 Output Value
ABS_SFRX( DAC1, 0xf00d);		// DAC1 Output Value
ABS_SFRX( PXCFG, 0xf00e);		// 8051 On-Chip Control
ABS_SFRX( ADDAEN, 0xf00f);		// ADC / DAC Enable
ABS_SFRX( E51_RST, 0xf010);		// 8051 Reset Control
ABS_SFRX( CODE_SEL, 0xf011);	// Code Source selection
ABS_SFRX( HOST_HS, 0xf012);		// Host Hand-Shaking
ABS_SFRX( ADCTRL, 0xf015);		// ADC Control Register
ABS_SFRX( ADCDAT1, 0xf016);		// ADC Data Output High Byte
ABS_SFRX( ADCDAT0, 0xf017);		// ADC Data Output Low Byte
ABS_SFRX( FIRMWARE_ID, 0xf018);	// Firmware ID
ABS_SFRX( VER_ID, 0xf019);		// Version ID
ABS_SFRX( IC_SKEW, 0xf01a);		// IC Skew
ABS_SFRX( CHIP_ID_H, 0xf01c);	// Chip ID High Byte
ABS_SFRX( CHIP_ID_L, 0xf01d);	// Chip ID Low Byte
ABS_SFRX( CLKCFG2, 0xf01f);		// Clock Configuration 2
ABS_SFRX( EDICFG, 0xf022);		// EDI Configuration Register
ABS_SFRX( EDISR, 0xf023);		// EDI Status Register
ABS_SFRX( EDIID, 0xf024);		// EDI Version ID
ABS_SFRX( ADCCTL2, 0xf026);		// ADC Control Register 2
ABS_SFRX( MFPCTRL, 0xf028);		// Multi-Function Pins Control Register
ABS_SFRX( CRY32CR, 0xf02a);		// 32Khz Control Register
ABS_SFRX( IOSCCR, 0xf02b);		// Internal OSC Control
ABS_SFRX( CLKEN_1, 0xf030);		// Clock Enable 1
ABS_SFRX( CLKEN_2, 0xf031);		// Clock Enable 2
ABS_SFRX( CLKEN_3, 0xf032);		// Clock Enable 3
ABS_SFRX( CLKEN_4, 0xf033);		// Clock Enable 4
ABS_SFRX( LVD_EN, 0xf034);		// Low Voltage Detect Enable
ABS_SFRX( LVD_TRIM, 0xf035);	// Low Voltage Detect Trim

// GPIO General purpose I/O

// we sometimes compute GPIO offsets, so define as an array
EXTERN volatile unsigned char __xdata ABS_ADDR(gpio[0x68], 0xfc00);

#define GPIOFS00 0x00      // Function Selection
#define GPIOFS08 0x01      //
#define GPIOFS10 0x02      //
#define GPIOFS18 0x03      //
#define GPIOFS20 0x04      //
#define GPIOFS28 0x05      //
#define GPIOFS30 0x06      //
#define GPIOFS38 0x07      //

#define GPIOOE00 0x10      // Output Enable
#define GPIOOE08 0x11      //
#define GPIOOE10 0x12      //
#define GPIOOE18 0x13      //
#define GPIOOE20 0x14      //
#define GPIOOE28 0x15      //
#define GPIOOE30 0x16      //
#define GPIOOE38 0x17      //

#define GPIOD00 0x20       // Output Data
#define GPIOD08 0x21       //
#define GPIOD10 0x22       //
#define GPIOD18 0x23       //
#define GPIOD20 0x24       //
#define GPIOD28 0x25       //
#define GPIOD30 0x26       //
#define GPIOD38 0x27       //

#define GPIOIN00 0x30      // Input Data
#define GPIOIN08 0x31      //
#define GPIOIN10 0x32      //
#define GPIOIN18 0x33      //
#define GPIOIN20 0x34      //
#define GPIOIN28 0x35      //
#define GPIOIN30 0x36      //
#define GPIOIN38 0x37      //

#define GPIOPU00 0x40      // Pull-up Enable
#define GPIORsv1 0x41      //
#define GPIOPU10 0x42      //
#define GPIOPU18 0x43      //
#define GPIOPU20 0x44      //
#define GPIOPU28 0x45      //
#define GPIOPU30 0x46      //
#define GPIOPU38 0x47      //

#define GPIOOD00 0x50      // Open Drain Enable
#define GPIORsv2 0x51      //
#define GPIOOD10 0x52      //
#define GPIOOD18 0x53      //
#define GPIOOD20 0x54      //
#define GPIOOD28 0x55      //
#define GPIOOD30 0x56      //
#define GPIOOD38 0x57      //

#define GPIOIE00 0x60      // Input Enable
#define GPIOIE08 0x61      //
#define GPIOIE10 0x62      //
#define GPIOIE18 0x63      //
#define GPIOIE20 0x64      //
#define GPIOIE28 0x65      //
#define GPIOIE30 0x66      //
#define GPIOIE38 0x67      //


// Consumer Electronics Control Interface (CEC)
ABS_SFRX( CEC_CFG, 0xfc80);		// CEC Configuration
ABS_SFRX( CEC_STS, 0xfc81);		// CEC Status
ABS_SFRX( CEC_ERRSTA, 0xfc82);	// CEC Error Code Status
ABS_SFRX( CEC_INTEN, 0xfc83);	// CEC Interrupt Enable
ABS_SFRX( CEC_EPF, 0xfc84);		// CEC Pending Flag
ABS_SFRX( CEC_FUNC, 0xfc85);	// CEC Function Control
ABS_SFRX( CEC_LA, 0xfc86);		// CEC Logical Address
ABS_SFRX( CEC_TXDATA, 0xfc87);	// CEC TX Data Byte
ABS_SFRX( CEC_RXDATA, 0xfc88);	// CEC RX Data Byte
ABS_SFRX( CEC_SBDT, 0xfc89);	// CEC Start Bit Duration Time
ABS_SFRX( CEC_DBTDT, 0xfc8a);	// CEC Data Bit Total Duration Time
ABS_SFRX( CEC_DBLDT, 0xfc8b);	// CEC Data Bit Low Duration Time
ABS_SFRX( CEC_SBCLD, 0xfc8c);	// CEC Start Bit Check Low Duration Time
ABS_SFRX( CEC_SBCTD, 0xfc8d);	// CEC Start Bit Check Total Duration Time
ABS_SFRX( CEC_SAMP_T, 0xfc8e);	// CEC Sample Time
ABS_SFRX( CEC_ELTFFB, 0xfc8f);	// CEC Earliest/Latest Time for the Following Bit
ABS_SFRX( CEC_EIP, 0xfc90);		// CEC Error Indication Period
ABS_SFRX( CEC_SFTP, 0xfc91);	// CEC Signal Free Time Plus
ABS_SFRX( CEC_SWRST, 0xfc92);	// CEC Software Reset
ABS_SFRX( CEC_OPT, 0xfc92);		// CEC Option

// Internal KeyBoard (IKB) Encoder
ABS_SFRX( IKBCFG, 0xfca0);		// IKB Configuration
ABS_SFRX( IKBLED, 0xfca1);		// IKB LED Control
ABS_SFRX( IKBTYPEC, 0xfca2);	// IKB Typematic Control
ABS_SFRX( IKBIE, 0xfca3);		// IKB Interrupt Enable
ABS_SFRX( IKBPF, 0xfca4);		// IKB Interrupt Pending Flag
ABS_SFRX( IKBTXDAT, 0xfca5);	// IKB PS/2 TX Data Byte
ABS_SFRX( IKBRXDAT, 0xfca6);	// IKB PS/2 RX Data Byte
ABS_SFRX( IKBHCFG, 0xfca7);		// IKB Hardware Mode Configuration
ABS_SFRX( IKBKSI, 0xfca8);		// IKB Scan Inputs
ABS_SFRX( IKBSADR, 0xfca9);		// IKB Scan Address
ABS_SFRX( IKBSDB, 0xfcaa);		// IKB Scan Timing Control
ABS_SFRX( IKBMK, 0xfcab);		// IKB Make Key (hardware mode)
ABS_SFRX( IKBBK, 0xfcac);		// IKB Break Key (hardware mode)
ABS_SFRX( IKBSADB, 0xfcad);		// IKB Scan All key de-bounce control
ABS_SFRX( IKBSFC, 0xfcae);		// IKB Scan Function Control
ABS_SFRX( IKBKGENFG, 0xfcaf);	// IKB Key Generation Flag

// One Wire Manager
ABS_SFRX( OWMCFG, 0xfcf0);		// OWM bus master configuration
ABS_SFRX( OWMSR, 0xfcf1);		// OWM bus master status
ABS_SFRX( OWMCMD, 0xfcf2);		// OWM bus master command
ABS_SFRX( OWMWB, 0xfcf3);		// OWM bus master write data buffer (transmit)
ABS_SFRX( OWMRB, 0xfcf4);		// OWM bus master read data buffer (receive)
ABS_SFRX( OWMRSTL, 0xfcf5);		// OWM reset/break low timing
ABS_SFRX( OWMRSTH, 0xfcf6);		// OWM reset/break high timing
ABS_SFRX( OWMWT, 0xfcf7);		// OWM write slot timing
ABS_SFRX( OWMW1L, 0xfcf8);		// OWM write 1 low timing
ABS_SFRX( OWMW0L, 0xfcf9);		// OWM write 0 low timing
ABS_SFRX( OWMRT, 0xfcfa);		// OWM read slot timing
ABS_SFRX( OWMRL, 0xfcfb);		// OWM read low timing
ABS_SFRX( OWMRS, 0xfcfc);		// OWM read sample timing

// SMBus Device Controller
ABS_SFRX( SMBDCFG, 0xfd10);		// SMBus Device Configuration
ABS_SFRX( SMBDIE, 0xfd11);		// SMBus Device Interrupt Enable
ABS_SFRX( SMBDPF, 0xfd12);		// SMBus Device Pending Flag
ABS_SFRX( SMBDSTS, 0xfd13);		// SMBus Device Status
ABS_SFRX( SMBDADR, 0xfd14);		// SMBus Device Address
ABS_SFRX( SMBDCMD, 0xfd15);		// SMBus Device Received Command
ABS_SFRX( SMBDCNT, 0xfd16);		// SMBus Device Byte Count
ABS_SFRX( SMBDRCNT, 0xfd17);	// SMBus Device Received Byte Count
ABS_SFRX( SMBDPEC, 0xfd18);		// SMBus Device PEC
ABS_SFRX( SMBDATA0, 0xfd19);	// SMBus Data Array (16 Bytes)
ABS_SFRX( SMBDATA1, 0xfd1a);	//
ABS_SFRX( SMBDATA2, 0xfd1b);	//
ABS_SFRX( SMBDATA3, 0xfd1c);	//
ABS_SFRX( SMBDATA4, 0xfd1d);	//
ABS_SFRX( SMBDATA5, 0xfd1e);	//
ABS_SFRX( SMBDATA6, 0xfd1f);	//
ABS_SFRX( SMBDATA7, 0xfd20);	//
ABS_SFRX( SMBDATA8, 0xfd21);	//
ABS_SFRX( SMBDATA9, 0xfd22);	//
ABS_SFRX( SMBDATA10, 0xfd23);	//
ABS_SFRX( SMBDATA11, 0xfd24);	//
ABS_SFRX( SMBDATA12, 0xfd25);	//
ABS_SFRX( SMBDATA13, 0xfd26);	//
ABS_SFRX( SMBDATA14, 0xfd27);	//
ABS_SFRX( SMBDATA15, 0xfd28);	//

// SMBus Slave Controller
ABS_SFRX( SMS0CFG, 0xfd40);		// SMBus Slave0 Configuration
ABS_SFRX( SMS0IE, 0xfd41);		// SMBus Slave0 Interrupt Enable
ABS_SFRX( SMS0PF, 0xfd42);		// SMBus Slave0 Pending Flag
ABS_SFRX( SMS0STS, 0xfd43);		// SMBus Slave0 Status
ABS_SFRX( SMS0ADR, 0xfd44);		// SMBus Slave0 Address
ABS_SFRX( SMS0CMD, 0xfd45);		// SMBus Slave0 Received Command
ABS_SFRX( SMS0CNT, 0xfd46);		// SMBus Slave0 Byte Count
ABS_SFRX( SMS0RCNT, 0xfd47);	// SMBus Slave0 Received Byte Count
ABS_SFRX( SMS0PEC, 0xfd48);		// SMBus Slave0 PEC
ABS_SFRX( SMS0DAT0, 0xfd49);	// SMBus Slave0 Data Array (16 Bytes)
ABS_SFRX( SMS0DAT1, 0xfd4a);	//
ABS_SFRX( SMS0DAT2, 0xfd4b);	//
ABS_SFRX( SMS0DAT3, 0xfd4c);	//
ABS_SFRX( SMS0DAT4, 0xfd4d);	//
ABS_SFRX( SMS0DAT5, 0xfd4e);	//
ABS_SFRX( SMS0DAT6, 0xfd4f);	//
ABS_SFRX( SMS0DAT7, 0xfd50);	//
ABS_SFRX( SMS0DAT8, 0xfd51);	//
ABS_SFRX( SMS0DAT9, 0xfd52);	//
ABS_SFRX( SMS0DAT10, 0xfd53);	//
ABS_SFRX( SMS0DAT11, 0xfd54);	//
ABS_SFRX( SMS0DAT12, 0xfd55);	//
ABS_SFRX( SMS0DAT13, 0xfd56);	//
ABS_SFRX( SMS0DAT14, 0xfd57);	//
ABS_SFRX( SMS0DAT15, 0xfd58);	//
ABS_SFRX( SMS1CFG, 0xfd60);		// SMBus Slave1 Configuration
ABS_SFRX( SMS1IE, 0xfd61);		// SMBus Slave1 Interrupt Enable
ABS_SFRX( SMS1PF, 0xfd62);		// SMBus Slave1 Pending Flag
ABS_SFRX( SMS1STS, 0xfd63);		// SMBus Slave1 Status
ABS_SFRX( SMS1ADR, 0xfd64);		// SMBus Slave1 Address
ABS_SFRX( SMS1CMD, 0xfd65);		// SMBus Slave1 Received Command
ABS_SFRX( SMS1CNT, 0xfd66);		// SMBus Slave1 Byte Count
ABS_SFRX( SMS1RCNT, 0xfd67);	// SMBus Slave1 Received Byte Count
ABS_SFRX( SMS1PEC, 0xfd68);		// SMBus Slave1 PEC
ABS_SFRX( SMS1DAT0, 0xfd69);	// SMBus Slave0 Data Array (16 Bytes)
ABS_SFRX( SMS1DAT1, 0xfd6a);	//
ABS_SFRX( SMS1DAT2, 0xfd6b);	//
ABS_SFRX( SMS1DAT3, 0xfd6c);	//
ABS_SFRX( SMS1DAT4, 0xfd6d);	//
ABS_SFRX( SMS1DAT5, 0xfd6e);	//
ABS_SFRX( SMS1DAT6, 0xfd6f);	//
ABS_SFRX( SMS1DAT7, 0xfd70);	//
ABS_SFRX( SMS1DAT8, 0xfd71);	//
ABS_SFRX( SMS1DAT9, 0xfd72);	//
ABS_SFRX( SMS1DAT10, 0xfd73);	//
ABS_SFRX( SMS1DAT11, 0xfd74);	//
ABS_SFRX( SMS1DAT12, 0xfd75);	//
ABS_SFRX( SMS1DAT13, 0xfd76);	//
ABS_SFRX( SMS1DAT14, 0xfd77);	//
ABS_SFRX( SMS1DAT15, 0xfd78);	//

// Pulse Width Modulation (PWM)
ABS_SFRX( PWMCFG, 0xfe00);		// PWM Configuration
ABS_SFRX( PWMCLK1, 0xfe01);		// PWM0, PWM1 CLOCK Source Selection
ABS_SFRX( PWMCLK2, 0xfe02);		// PWM2, PWM3 CLOCK Source Selection
ABS_SFRX( PWM0LOWH, 0xfe03);	// PWM0 High Byte of Low Period Length
ABS_SFRX( PWM0LOWL, 0xfe04);	// PWM0 Low Byte of Low Period Length
ABS_SFRX( PWM0HIGHH, 0xfe05);	// PWM0 High Byte of High Period Length
ABS_SFRX( PWM0HIGHL, 0xfe06);	// PWM0 Low Byte of High Period Length
ABS_SFRX( PWM1HIGHH, 0xfe07);	// PWM1 High Period Length (12-bit)
ABS_SFRX( PWM1HIGHL, 0xfe08);	//
ABS_SFRX( PWM1CYCH, 0xfe09);	// PWM1 Cycle Period Length (12-bit)
ABS_SFRX( PWM1CYCL, 0xfe0a);	//
ABS_SFRX( PWM2HIGHH, 0xfe0b);	// PWM2 High Period Length (12-bit)
ABS_SFRX( PWM2HIGHL, 0xfe0c);	//
ABS_SFRX( PWM2CYCH, 0xfe0d);	// PWM2 Cycle Period Length (12-bit)
ABS_SFRX( PWM2CYCL, 0xfe0e);	//
ABS_SFRX( PWM3HIGHH, 0xfe0f);	// PWM3 High Period Length (12-bit)
ABS_SFRX( PWM3HIGHL, 0xfe10);	//
ABS_SFRX( PWM3CYCH, 0xfe11);	// PWM3 Cycle Period Length (12-bit)
ABS_SFRX( PWM3CYCL, 0xfe12);	//

// Digital Sampler
ABS_SFRX( DSCC0, 0xfe20);		// Digital Sampler0 Controller Configuration
ABS_SFRX( DSSMONH0, 0xfe21);	// Digital Sampler 0 Speed Monitor Counter Value (12-bit)
ABS_SFRX( DSSMONL0, 0xfe22);	//
ABS_SFRX( DSCC1, 0xfe30);		// Digital Sampler1 Controller Configuration
ABS_SFRX( DSSMONH1, 0xfe31);	// Digital Sampler 1 Speed Monitor Counter Value (12-bit)
ABS_SFRX( DSSMONL1, 0xfe32);	//


// SPI Device Interface Controller
ABS_SFRX( SPID_CFG, 0xfe40);	// SPI Device Configuration
ABS_SFRX( SPID_RXFIFO, 0xfe41);	// SPI Device RX FIFO Point
ABS_SFRX( SPID_TXFIFO, 0xfe42);	// SPI Device TX FIFO Point
ABS_SFRX( SPID_STA, 0xfe43);	// SPI Device Status

// General Purpose Timer (GPT)
ABS_SFRX( GPTCFG, 0xfe50);		// GPT Configuration
ABS_SFRX( GPTPF, 0xfe51);		// GPT Pending Flag
ABS_SFRX( GPT0, 0xfe53);		// GPT0 Counter Value
ABS_SFRX( GPTRSV, 0xfe54);		// reserved
ABS_SFRX( GPT1, 0xfe55);		// GPT1 Counter Value
ABS_SFRX( GPT2H, 0xfe56);		// GPT2 Counter Value (16-bit)
ABS_SFRX( GPT2L, 0xfe57);		//
ABS_SFRX( GPT3H, 0xfe58);		// GPT3 Counter Value (16-bit)
ABS_SFRX( GPT3L, 0xfe59);		//

// SPI Host Interface Controller
ABS_SFRX( SHICSR, 0xfe70);		// SPI Host Interface Control Status Register
ABS_SFRX( SHITBUF, 0xfe71);		// SDI host interface transmit data port
ABS_SFRX( SHIRBUF, 0xfe72);		// SDI host interface receive data port

//  Watchdog Timer (WDT)
ABS_SFRX( WDTCFG, 0xfe80);		// WDT Configuration
ABS_SFRX( WDTPF, 0xfe81);		// WDT Pending Flag
ABS_SFRX( WDT, 0xfe82);			// WDT High 8-bit Counter Value (for WDT reset system of 10 bits counter)
ABS_SFRX( LEDCFG, 0xfe83);		// WDT Breathing LED Configuration
ABS_SFRX( TMR_CFG, 0xfe84);		// WDT TMR (24-bit Timer) Configuration
ABS_SFRX( TMR_MATCH, 0xfe85);	// WDT TMR (24-bit Timer) Counter Match Value
ABS_SFRX( TMR_V1, 0xfe86);		// WDT TMR (24-bit Timer) Counter Value 1
ABS_SFRX( TMR_V2, 0xfe87);		// WDT TMR (24-bit Timer) Counter Value 2

// X-Bus Interface (XBI)
ABS_SFRX( XBIEFCFG, 0xfea0);	// XBI Embedded Flash Configuration
ABS_SFRX( XBIEFSIG1, 0xfea1);	// XBI Embedded Flash signals 1 in FW mode
ABS_SFRX( XBIEFSIG2, 0xfea2);	// XBI Embedded Flash signals 2 in FW mode
ABS_SFRX( XBIPUMP, 0xfea3);		// XBI Pump IP trimming bits
ABS_SFRX( XBIFM, 0xfea4);		// XBI Flash IP trimming bits
ABS_SFRX( XBIVR, 0xfea5);		// XBI VR IP trimming bits
ABS_SFRX( XBIMISC, 0xfea6);		// XBI MISC Reg
ABS_SFRX( XBIEFCMD, 0xfea7);	// XBI Embedded Flash Command Port
ABS_SFRX( XBIEFA0, 0xfea8);		// XBI Embedded Flash Address (15-bit) = [XBIEFA1(7bit) : XBIEFA0(8bit)]
ABS_SFRX( XBIEFA1, 0xfea9);		// XBI Embedded Flash Address (15-bit) = [XBIEFA1(7bit) : XBIEFA0(8bit)]
ABS_SFRX( XBIEFDO, 0xfeaa);		// XBI Embedded Flash Output Data Port
ABS_SFRX( XBIEFDI, 0xfeab);		// XBI Embedded Flash Input Data Port
ABS_SFRX( XBIERCFG, 0xfeb0);	// XBI Embedded ROM Configuration
ABS_SFRX( XBIERTRIM, 0xfeb1);	// XBI Embedded ROM Trim bits
ABS_SFRX( XBIERADDR0, 0xfeb2);	// XBI Embedded ROM Address (12-bit) = [XBIEFA1(4bit) : XBIEFA0(8bit)]
ABS_SFRX( XBIERADDR1, 0xfeb3);	// XBI Embedded ROM Address (12-bit) = [XBIEFA1(4bit) : XBIEFA0(8bit)]
ABS_SFRX( XBIERDATA, 0xfeb4);	// XBI Embedded ROM Data

// Consumer IR Controller (CIR)
ABS_SFRX( CIRCFG, 0xfec0);		// CIR Configuration
ABS_SFRX( CIRCFG2, 0xfec1);		// CIR Configuration 2
ABS_SFRX( CIRPF, 0xfec2);		// CIR Pending Flag and Status
ABS_SFRX( CIRHIGH, 0xfec3);		// Value for High Pulse Width
ABS_SFRX( CIRBIT, 0xfec4);		// Value for Bit Width(RC5/RC6) / Logic Bit-One (NEC)
ABS_SFRX( CIRSTART, 0xfec5);	// Value for Leader Pulse Width (RC6/NEC) for Normal Packet
ABS_SFRX( CIRSTART2, 0xfec6);	// Value for Tailer Bit Width (RC6) / Leader Width of Repeat Packet (NEC)
ABS_SFRX( CIRDAT_IN, 0xfec7);	// CIR Decode Data Byte
ABS_SFRX( CIRRLC_CFG, 0xfec8);	// CIR Counter Value for RLC Sample Period
ABS_SFRX( CIRRLC_OUT0, 0xfec9);	// CIR RLC Output 1st Byte
ABS_SFRX( CIRRLC_OUT1, 0xfeca);	// CIR	RLC Output 2nd Byte
ABS_SFRX( CIRCAR_PULS, 0xfecb);	// CIR Carrier Discard/Average Pulse Number Setting for Automatic Carrier Detection.
ABS_SFRX( CIRCAR_PRD, 0xfecc);	// CIR Detected Carrier Period
ABS_SFRX( CIRCAR_HPRD, 0xfecd);	// CIR Detected Pulse Width High of Carrier
ABS_SFRX( CIRMOD_PRD, 0xfece);	// CIR Modulation Carrier Period (RLC only)
ABS_SFRX( CIRMOD_HPRD, 0xfecf);	// CIR Pulse Width High of Modulation Carrier (RLC only)

// PS/2 Interface (PS/2)
/* -- this section intentionally left blank -- */

// General Purpose Wake-up Controller (GPWU)

// we sometimes compute GPWU offsets, so an array can be easier
EXTERN volatile unsigned char __xdata ABS_ADDR(gpwu[0x50],0xff30);
#define GPWUEN00	0x00  // GPIO Wakeup Event Enable
#define GPWUPF00	0x10  // GPIO Wakeup Event Pending Flag
#define GPWUPS00	0x20  // GPIO Wakeup Polarity Selection
#define GPWUEL00	0x30  // GPIO Wakeup Level/Edge Trigger Selection
#define GPWUCHG00	0x40  // GPIO Wakeup Input Change (Toggle) Trigger Selection                      Note:This setting will ignore the corresponding bit of GPWUELxx.

// System Management Bus (SMBus) Master Controller
ABS_SFRX( SMB0RSA, 0xff90);		// SMBus Slave Address
ABS_SFRX( SMB0TCRC, 0xff92);	// SMBus CRC Value
ABS_SFRX( SMB0PIN, 0xff93);		// SMBus Pin Control
ABS_SFRX( SMB0CFG, 0xff94);		// SMBus Configuration
ABS_SFRX( SMB0EN, 0xff95);		// SMBus Interrupt Enable
ABS_SFRX( SMB0PF, 0xff96);		// SMBus Interrupt Pending Flag
ABS_SFRX( SMB0RCRC, 0xff97);	// SMBus Received CRC Value
ABS_SFRX( SMB0PRTCL, 0xff98);	// SMBus Protocol
ABS_SFRX( SMB0STS, 0xff99);		// SMBus Status
ABS_SFRX( SMB0ADR, 0xff9a);		// SMBus Address Port (For I2C Mode)
ABS_SFRX( SMB0CMD, 0xff9b);		// SMBus Command Port
ABS_SFRX( SMB0DAT0, 0xff9c);	// SMBus Data Array (32 Bytes)
ABS_SFRX( SMB0DAT1, 0xff9d);	//
ABS_SFRX( SMB0DAT2, 0xff9e);	//
ABS_SFRX( SMB0DAT3, 0xff9f);	//
ABS_SFRX( SMB0DAT4, 0xffa0);	//
ABS_SFRX( SMB0DAT5, 0xffa1);	//
ABS_SFRX( SMB0DAT6, 0xffa2);	//
ABS_SFRX( SMB0DAT7, 0xffa3);	//
ABS_SFRX( SMB0DAT8, 0xffa4);	//
ABS_SFRX( SMB0DAT9, 0xffa5);	//
ABS_SFRX( SMB0DAT10, 0xffa6);	//
ABS_SFRX( SMB0DAT11, 0xffa7);	//
ABS_SFRX( SMB0DAT12, 0xffa8);	//
ABS_SFRX( SMB0DAT13, 0xffa9);	//
ABS_SFRX( SMB0DAT14, 0xffaa);	//
ABS_SFRX( SMB0DAT15, 0xffab);	//
ABS_SFRX( SMB0DAT16, 0xffac);	//
ABS_SFRX( SMB0DAT17, 0xffad);	//
ABS_SFRX( SMB0DAT18, 0xffae);	//
ABS_SFRX( SMB0DAT19, 0xffaf);	//
ABS_SFRX( SMB0DAT20, 0xffb0);	//
ABS_SFRX( SMB0DAT21, 0xffb1);	//
ABS_SFRX( SMB0DAT22, 0xffb2);	//
ABS_SFRX( SMB0DAT23, 0xffb3);	//
ABS_SFRX( SMB0DAT24, 0xffb4);	//
ABS_SFRX( SMB0DAT25, 0xffb5);	//
ABS_SFRX( SMB0DAT26, 0xffb6);	//
ABS_SFRX( SMB0DAT27, 0xffb7);	//
ABS_SFRX( SMB0DAT28, 0xffb8);	//
ABS_SFRX( SMB0DAT29, 0xffb9);	//
ABS_SFRX( SMB0DAT30, 0xffba);	//
ABS_SFRX( SMB0DAT31, 0xffbb);	//
ABS_SFRX( SMB0CNT, 0xffbc);		// SMBus Block Count
ABS_SFRX( SMB0AADR, 0xffbd);	// SMBus Alarm (Host Notify Protocol) Address / SMBus Slave Received Command Code
ABS_SFRX( SMB0ADAT0, 0xffbe);	// SMBus Alarm Data
ABS_SFRX( SMB0ADAT1, 0xffbf);	//
ABS_SFRX( SMB1RSA, 0xffd0);		// SMBus Slave Address
ABS_SFRX( SMB1TCRC, 0xffd2);	// SMBus CRC Value
ABS_SFRX( SMB1PIN, 0xffd3);		// SMBus Pin Control
ABS_SFRX( SMB1CFG, 0xffd4);		// SMBus Configuration
ABS_SFRX( SMB1EN, 0xffd5);		// SMBus Interrupt Enable
ABS_SFRX( SMB1PF, 0xffd6);		// SMBus Interrupt Pending Flag
ABS_SFRX( SMB1RCRC, 0xffd7);	// SMBus Received CRC Value
ABS_SFRX( SMB1PRTCL, 0xffd8);	// SMBus Protocol
ABS_SFRX( SMB1STS, 0xffd9);		// SMBus Status
ABS_SFRX( SMB1ADR, 0xffda);		// SMBus Address Port
ABS_SFRX( SMB1CMD, 0xffdb);		// SMBus Command Port
ABS_SFRX( SMB1DAT0, 0xffdc);    // SMBus Data Array (32 Bytes)
ABS_SFRX( SMB1DAT1, 0xffdd);    //
ABS_SFRX( SMB1DAT2, 0xffde);    //
ABS_SFRX( SMB1DAT3, 0xffdf);    //
ABS_SFRX( SMB1DAT4, 0xffe0);    //
ABS_SFRX( SMB1DAT5, 0xffe1);    //
ABS_SFRX( SMB1DAT6, 0xffe2);    //
ABS_SFRX( SMB1DAT7, 0xffe3);    //
ABS_SFRX( SMB1DAT8, 0xffe4);    //
ABS_SFRX( SMB1DAT9, 0xffe5);    //
ABS_SFRX( SMB1DAT10, 0xffe6);   //
ABS_SFRX( SMB1DAT11, 0xffe7);   //
ABS_SFRX( SMB1DAT12, 0xffe8);   //
ABS_SFRX( SMB1DAT13, 0xffe9);   //
ABS_SFRX( SMB1DAT14, 0xffea);   //
ABS_SFRX( SMB1DAT15, 0xffeb);   //
ABS_SFRX( SMB1DAT16, 0xffec);   //
ABS_SFRX( SMB1DAT17, 0xffed);   //
ABS_SFRX( SMB1DAT18, 0xffee);   //
ABS_SFRX( SMB1DAT19, 0xffef);   //
ABS_SFRX( SMB1DAT20, 0xfff0);   //
ABS_SFRX( SMB1DAT21, 0xfff1);   //
ABS_SFRX( SMB1DAT22, 0xfff2);   //
ABS_SFRX( SMB1DAT23, 0xfff3);   //
ABS_SFRX( SMB1DAT24, 0xfff4);   //
ABS_SFRX( SMB1DAT25, 0xfff5);   //
ABS_SFRX( SMB1DAT26, 0xfff6);   //
ABS_SFRX( SMB1DAT27, 0xfff7);   //
ABS_SFRX( SMB1DAT28, 0xfff8);   //
ABS_SFRX( SMB1DAT29, 0xfff9);   //
ABS_SFRX( SMB1DAT30, 0xfffa);   //
ABS_SFRX( SMB1DAT31, 0xfffb);   //
ABS_SFRX( SMB1CNT, 0xfffc);		// SMBus Block Count
ABS_SFRX( SMB1AADR, 0xfffd);	// SMBus Alarm (Host Notify Protocol) Address / SMBus Slave Received Command Code
ABS_SFRX( SMB1ADAT0, 0xfffe);	// SMBus Alarm Data
ABS_SFRX( SMB1ADAT1, 0xffff);	//


// 8051 registers

ABS_SFR(P0IE,  0x80); // P0 Interrupt Enable register
ABS_SBIT(P0IE0, 0x80, 0);
ABS_SBIT(P0IE1, 0x80, 1);
ABS_SBIT(P0IE2, 0x80, 2);
ABS_SBIT(P0IE3, 0x80, 3);
ABS_SBIT(P0IE4, 0x80, 4);
ABS_SBIT(P0IE5, 0x80, 5);
ABS_SBIT(P0IE6, 0x80, 6);
ABS_SBIT(P0IE7, 0x80, 7);

ABS_SFR(PCON2, 0x86); // Processor Control register 2
ABS_SFR(PCON,  0x87); // Processor Control register

ABS_SFR( TCON, 0x88);
ABS_SBIT( IT0 , 0x88, 0);
ABS_SBIT( IE0 , 0x88, 1);
ABS_SBIT( IT1 , 0x88, 2);
ABS_SBIT( IE1 , 0x88, 3);
ABS_SBIT( TR0 , 0x88, 4);
ABS_SBIT( TF0 , 0x88, 5);
ABS_SBIT( TR1 , 0x88, 6);
ABS_SBIT( TF1 , 0x88, 7);

ABS_SFR( TMOD, 0x89);
ABS_SFR( TL0, 0x8A);
ABS_SFR( TL1, 0x8B);
ABS_SFR( TH0, 0x8C);
ABS_SFR( TH1, 0x8D);

ABS_SFR(P2, 0xa0); // Port 2 Register

ABS_SFR(IE, 0xa8); // Interrupt Enable Register.
ABS_SBIT(EX0, 0xa8, 0); // Enable External Interrupt INT0.
ABS_SBIT(ET0, 0xa8, 1); // Enable Timer 0 Interrupt.
ABS_SBIT(EX1, 0xa8, 2); // Enable External Interrupt INT1.
ABS_SBIT(ET1, 0xa8, 3); // Enable Timer 1 Interrupt.
ABS_SBIT(ES,  0xa8, 4); // Enable UART0 Interrupt.
ABS_SBIT(EP,  0xa8, 6); // ??? Interrupt Event to Event pending ???
ABS_SBIT(EA,  0xa8, 7); // Global enable interrupt.

ABS_SFR(SCON, 0x98);
ABS_SBIT(RI,  0x98, 0); // Receive interrupt flag.
ABS_SBIT(TI,  0x98, 1); // Transmit interrupt flag.
ABS_SBIT(RB8, 0x98, 2); // In Modes 2 and 3, the 9th data bit that was received.
ABS_SBIT(TB8, 0x98, 3); // The 9th data bit that will be transmitted in Modes 2 and 3.
ABS_SBIT(REN, 0x98, 4); // Enables serial reception.
ABS_SBIT(SM2, 0x98, 5); // Serial Port Mode Bit 2.
ABS_SBIT(SM1, 0x98, 6); // Serial Port Mode Bit 1.
ABS_SBIT(SM0, 0x98, 7); // Serial Port Mode Bit 0.

ABS_SFR(SBUF, 0x99); // Serial Port UART0 Data Buffer.
ABS_SFR(SCON2, 0x9a); // Serial Port Baud timer, hi byte
ABS_SFR(SCON3, 0x9b); // Serial Port Baud timer, low byte
ABS_SFR(SCON4, 0x9c); // Serial Port clock divisor

ABS_SFR(P1IE,  0x90); // P1 Interrupt Enable register
ABS_SBIT(P1IE0, 0x90, 0);
ABS_SBIT(P1IE1, 0x90, 1);
ABS_SBIT(P1IE2, 0x90, 2);
ABS_SBIT(P1IE3, 0x90, 3);
ABS_SBIT(P1IE4, 0x90, 4);
ABS_SBIT(P1IE5, 0x90, 5);
ABS_SBIT(P1IE6, 0x90, 6);
ABS_SBIT(P1IE7, 0x90, 7);

ABS_SFR(P3IE,  0xb0); // P3 Interrupt Enable register
ABS_SBIT(P3IE0, 0xb0, 0);
ABS_SBIT(P3IE1, 0xb0, 1);
ABS_SBIT(P3IE2, 0xb0, 2);
ABS_SBIT(P3IE3, 0xb0, 3);
ABS_SBIT(P3IE4, 0xb0, 4);
ABS_SBIT(P3IE5, 0xb0, 5);
ABS_SBIT(P3IE6, 0xb0, 6);
ABS_SBIT(P3IE7, 0xb0, 7);

ABS_SFR(P0IF,  0xd8); // P0 Interrupt Flag register
ABS_SFR(P1IF,  0xe8); // P1 Interrupt Flag register

ABS_SFR(ACC, 0xe0);	// accumulator

ABS_SFR(P3IF,  0xf8); // P3 Interrupt Flag register
ABS_SBIT(P3IF0, 0xf8, 0);
ABS_SBIT(P3IF1, 0xf8, 1);
ABS_SBIT(P3IF2, 0xf8, 2);
ABS_SBIT(P3IF3, 0xf8, 3);
ABS_SBIT(P3IF4, 0xf8, 4);
ABS_SBIT(P3IF5, 0xf8, 5);
ABS_SBIT(P3IF6, 0xf8, 6);
ABS_SBIT(P3IF7, 0xf8, 7);

ABS_SFR(SP, 0x81); // Stack Pointer.


// Using macros rather than functions makes the code size smaller.
#define USE_MACROS_FOR_IO 1

#if USE_MACROS_FOR_IO

#define enable_SOC_RESET(void)			do { IO_OUTPUT_LOW(GPIO_02); } while(0)
#define disable_SOC_RESET(void)			do { IO_OUTPUT_HIGH(GPIO_02); } while(0)
#define output_enable_SOC_RESET(void)	do { IO_OPEN_DRAIN_ENABLE(GPIO_02); \
											 IO_OUTPUT_ENABLE(GPIO_02); } while(0)

#define enable_EN_1_8V_GPIO()			do { IO_OUTPUT_LOW(GPIO_04); } while(0)
#define disable_EN_1_8V_GPIO()			do { IO_OUTPUT_HIGH(GPIO_04); } while(0)
#define output_enable_EN_1_8V_GPIO()	do { IO_OUTPUT_ENABLE(GPIO_04); } while(0)
#define output_disable_EN_1_8V_GPIO()	do { IO_OUTPUT_DISABLE(GPIO_04); } while(0)

#define enable_EN_USB_PWR()				do { IO_OUTPUT_HIGH(GPIO_05); } while(0)
#define disable_EN_USB_PWR()			do { IO_OUTPUT_LOW(GPIO_05); } while(0)
#define output_enable_EN_USB_PWR()		do { IO_OUTPUT_ENABLE(GPIO_05); } while(0)
#define output_disable_EN_USB_PWR()		do { IO_OUTPUT_DISABLE(GPIO_05); } while(0)

#define set_LED_CHG_RED_on() 			do { IO_OUTPUT_HIGH(GPIO_07); } while(0)
#define set_LED_CHG_RED_off() 			do { IO_OUTPUT_LOW(GPIO_07); } while (0)
#define output_enable_LED_CHG_RED()		do { IO_OUTPUT_ENABLE(GPIO_07); } while(0)
#define output_disable_LED_CHG_RED() 		do { IO_OUTPUT_DISABLE(GPIO_07); } while(0)

// this is a function so it can key from board_rev
#define GPIO_SOC_SLEEP	GPIO_0B
#define read_SOC_SLEEP()				( IO_ACTIVE_HIGH(GPIO_0B) )
#define input_enable_SOC_SLEEP() 		do { IO_INPUT_ONLY(GPIO_0B); } while(0)

#define set_LED_CHG_GREEN_on() 			do { IO_OUTPUT_HIGH(GPIO_16); } while(0)
#define set_LED_CHG_GREEN_off() 		do { IO_OUTPUT_LOW(GPIO_16); } while(0)
#define output_enable_LED_CHG_GREEN() 		do { IO_OUTPUT_ENABLE(GPIO_16); } while(0)
#define output_disable_LED_CHG_GREEN() 		do { IO_OUTPUT_DISABLE(GPIO_16); } while(0)

#define enable_EN_VCORE_PWR()			do { IO_OUTPUT_HIGH(GPIO_17); } while(0)
#define disable_EN_VCORE_PWR()		 	do { IO_OUTPUT_LOW(GPIO_17); } while (0)
#define output_enable_EN_VCORE_PWR() 	do { IO_OUTPUT_ENABLE(GPIO_17); } while (0)
#define output_disable_EN_VCORE_PWR() 	do { IO_OUTPUT_DISABLE(GPIO_17); } while (0)

#define set_LED_PWR_on()				do { IO_OUTPUT_HIGH(GPIO_19); } while(0)
#define set_LED_PWR_off()				do { IO_OUTPUT_LOW(GPIO_19); } while(0)
#define read_LED_PWR(void)				( IO_ACTIVE_HIGH(GPIO_19) )
#define input_enable_LED_PWR()			do { IO_INPUT_ENABLE(GPIO_19); } while(0)
#define output_enable_LED_PWR()			do { IO_OUTPUT_ENABLE(GPIO_19); } while(0)
#define output_disable_LED_PWR()		do { IO_OUTPUT_DISABLE(GPIO_19); } while(0)

#define enable_EC_IRQ(void)				do { IO_OUTPUT_LOW(GPIO_18); } while(0)
#define disable_EC_IRQ(void)			do { IO_OUTPUT_HIGH(GPIO_18); } while(0)
#define output_enable_EC_IRQ(void)		do { IO_OUTPUT_ENABLE(GPIO_18); } while(0)
#define output_disable_EC_IRQ(void)		do { IO_OUTPUT_DISABLE(GPIO_18); } while(0)

#define enable_EN_DCON_PWR(void)		do { IO_OUTPUT_LOW(GPIO_1A); } while(0)
#define disable_EN_DCON_PWR(void)		do { IO_OUTPUT_HIGH(GPIO_1A); } while(0)
#define output_enable_EN_DCON_PWR(void)	do { IO_OUTPUT_ENABLE(GPIO_1A); } while(0)
#define output_disable_EN_DCON_PWR(void)	do { IO_OUTPUT_DISABLE(GPIO_1A); } while(0)

#define read_SYS_RESET()				( IO_ACTIVE_LOW(GPIO_1B) )
#define input_enable_SYS_RESET() 		do { IO_INPUT_ONLY(GPIO_1B); } while(0)

#define read_ALL_PWRGOOD()				( IO_ACTIVE_HIGH(GPIO_1C) )
#define input_enable_ALL_PWRGOOD(void)	do { IO_INPUT_ONLY(GPIO_1C); } while(0)

#define GPIO_EC_RX		GPIO_1D		// serial RX line

#define enable_EN_1_8V_PMIC(void)		do { IO_OUTPUT_LOW(GPIO_1F); } while(0)
#define disable_EN_1_8V_PMIC(void)		do { IO_OUTPUT_HIGH(GPIO_1F); } while(0)
#define output_enable_EN_1_8V_PMIC(void) do { IO_OUTPUT_ENABLE(GPIO_1F); } while(0)
#define output_disable_EN_1_8V_PMIC(void) do { IO_OUTPUT_DISABLE(GPIO_1F); } while(0)

#define enable_EN_3_3V_SOC(void)		do { IO_OUTPUT_LOW(GPIO_22); } while(0)
#define disable_EN_3_3V_SOC(void)		do { IO_OUTPUT_HIGH(GPIO_22); } while(0)
#define output_enable_EN_3_3V_SOC(void) do { IO_OUTPUT_ENABLE(GPIO_22); } while(0)
#define output_disable_EN_3_3V_SOC(void) do { IO_OUTPUT_DISABLE(GPIO_22); } while(0)

#define GPIO_CHRG_AC_OK		GPIO_23
#define read_CHRG_AC_OK(void)			( IO_ACTIVE_HIGH(GPIO_23) )
#define input_enable_CHRG_AC_OK(void)	do { IO_INPUT_ONLY(GPIO_23); } while(0)

#define enable_EN_MAIN_PWR(void)		do { IO_OUTPUT_HIGH(GPIO_24); } while(0)
#define disable_EN_MAIN_PWR(void)		do { IO_OUTPUT_LOW(GPIO_24); } while(0)
#define output_enable_EN_MAIN_PWR(void) do { IO_OUTPUT_ENABLE(GPIO_24); } while(0)
#define output_disable_EN_MAIN_PWR(void) do { IO_OUTPUT_DISABLE(GPIO_24); } while(0)

#define enable_EN_3_3V_NAND(void)		do { IO_OUTPUT_LOW(GPIO_26); } while(0)
#define disable_EN_3_3V_NAND(void)		do { IO_OUTPUT_HIGH(GPIO_26); } while(0)
#define output_enable_EN_3_3V_NAND(void) do { IO_OUTPUT_ENABLE(GPIO_26); } while(0)
#define output_disable_EN_3_3V_NAND(void) do { IO_OUTPUT_DISABLE(GPIO_26); } while(0)

#define enable_EN_1_5V_DDR3(void)		do { IO_OUTPUT_HIGH(GPIO_27); } while(0)
#define disable_EN_1_5V_DDR3(void)		do { IO_OUTPUT_LOW(GPIO_27); } while(0)
#define output_enable_EN_1_5V_DDR3(void) do { IO_OUTPUT_ENABLE(GPIO_27); } while(0)
#define output_disable_EN_1_5V_DDR3(void) do { IO_OUTPUT_DISABLE(GPIO_27); } while(0)

#define enable_EN_1_2V(void)			do { IO_OUTPUT_HIGH(GPIO_28); } while(0)
#define disable_EN_1_2V(void)			do { IO_OUTPUT_LOW(GPIO_28); } while(0)
#define output_enable_EN_1_2V(void)		do { IO_OUTPUT_ENABLE(GPIO_28); } while(0)
#define output_disable_EN_1_2V(void)		do { IO_OUTPUT_DISABLE(GPIO_28); } while(0)

#define GPIO_PWR_BTN	GPIO_2A
#define read_PWR_BTN(void)				( IO_ACTIVE_LOW(GPIO_2A) )
#define input_enable_PWR_BTN(void)		do { IO_INPUT_ONLY(GPIO_2A); } while(0)

// These have to be functions so they can key off of
// the board rev ID.
//#define enable_EN_KBD_PWR(void)			do { IO_OUTPUT_LOW(GPIO_32); } while(0)
//#define disable_EN_KBD_PWR(void) 		do { IO_OUTPUT_HIGH(GPIO_32); } while(0)
//#define output_enable_EN_KBD_PWR(void)	do { IO_OUTPUT_ENABLE(GPIO_32); } while(0)
//#define output_disable_EN_KBD_PWR(void)	do { IO_OUTPUT_DISABLE(GPIO_32); } while(0)

#define enable_LED_INHIBIT(void)		do { IO_OUTPUT_LOW(GPIO_29); } while(0)
#define disable_LED_INHIBIT(void)		do { IO_OUTPUT_HIGH(GPIO_29); } while(0)
#define output_enable_LED_INHIBIT(void) do { IO_OUTPUT_ENABLE(GPIO_29); } while(0)


#define GPIO_EC_SPI_ACK		GPIO_25
#define GPIO_EC_SPI_CMD		GPIO_2F


#define GPIO_CHG_SDA			GPIO_2D
#define GPIO_CHG_SCL			GPIO_2E
#define SMBusDatLow() 					do { IO_OUTPUT_LOW(GPIO_CHG_SDA); } while(0)
#define SMBusDatHigh()					do { IO_OUTPUT_HIGH(GPIO_CHG_SDA); } while(0)
#define SMBusClkLow()					do { IO_OUTPUT_LOW(GPIO_CHG_SCL); } while(0)
#define SMBusClkHigh()					do { IO_OUTPUT_HIGH(GPIO_CHG_SCL); } while(0)
#define output_disable_SDA()			do { IO_OUTPUT_DISABLE(GPIO_CHG_SDA); } while(0)
#define output_enable_SDA()				do { IO_OUTPUT_ENABLE(GPIO_CHG_SDA); } while(0)
#define output_disable_SCL()			do { IO_OUTPUT_DISABLE(GPIO_CHG_SCL); } while(0)
#define output_enable_SCL()				do { IO_OUTPUT_ENABLE(GPIO_CHG_SCL); } while(0)
#define input_enable_SDA()				do { IO_INPUT_ENABLE(GPIO_CHG_SDA); } while(0)
#define read_SDA()						IO_ACTIVE_HIGH(GPIO_CHG_SDA)

#define enable_CHRG_TRICKLE(void)		do { IO_OUTPUT_HIGH(GPIO_30); } while (0)
#define disable_CHRG_TRICKLE(void)		do { IO_OUTPUT_LOW(GPIO_30); } while (0)
#define output_enable_CHRG_TRICKLE(void) do { IO_OUTPUT_ENABLE(GPIO_30); } while (0)

/* note:  as of A2, EN_SD1_PWR and EN_SD2_PWR are mislabeled on the
 * schematic.  they are now active low signals, because Q16 and Q21 have been
 * shorted.
 */
#define enable_EN_SD1_PWR(void)			do { IO_OUTPUT_LOW(GPIO_20); } while(0)
#define disable_EN_SD1_PWR(void)		do { IO_OUTPUT_HIGH(GPIO_20); } while(0)
#define output_enable_EN_SD1_PWR(void)	do { IO_OUTPUT_ENABLE(GPIO_20); } while(0)
#define output_disable_EN_SD1_PWR(void)	do { IO_OUTPUT_DISABLE(GPIO_20); } while(0)

#define enable_EN_SD2_PWR(void)			do { IO_OUTPUT_LOW(GPIO_21); } while(0)
#define disable_EN_SD2_PWR(void)		do { IO_OUTPUT_HIGH(GPIO_21); } while(0)
#define output_enable_EN_SD2_PWR(void)	do { IO_OUTPUT_ENABLE(GPIO_21); } while(0)
#define output_disable_EN_SD2_PWR(void)	do { IO_OUTPUT_DISABLE(GPIO_21); } while(0)

#define enable_CHRG_DQ(void)			do { IO_OUTPUT_LOW(GPIO_06); } while(0)
#define disable_CHRG_DQ(void)			do { IO_OUTPUT_HIGH(GPIO_06); } while(0)
#define output_enable_CHRG_DQ(void)		do { IO_OUTPUT_ENABLE(GPIO_06); } while(0)
#define output_disable_CHRG_DQ(void)	do { IO_OUTPUT_DISABLE(GPIO_06); } while(0)
#define input_disable_CHRG_DQ(void)		do { IO_INPUT_DISABLE(GPIO_06); } while (0)
#define input_enable_CHRG_DQ(void)		do { IO_INPUT_ENABLE(GPIO_06); } while (0)

#define read_PWR_LMT_ON(void)				( IO_ACTIVE_LOW(GPIO_03) )
#define input_enable_PWR_LMT_ON(void)		do { IO_INPUT_ONLY(GPIO_03); } while (0)

#define read_RESTORE(void)				( IO_ACTIVE_LOW(GPIO_31) )
#define input_enable_RESTORE(void)		do { IO_INPUT_ONLY(GPIO_31); } while (0)

#define GPIO_EDI_CS	GPIO_33

#ifdef NO_PS2
#define GPIO_EC_TPD_DAT	GPIO_35
#define GPIO_EC_TPD_CLK	GPIO_36
#define GPIO_EC_KBD_CLK	GPIO_37
#define GPIO_EC_KBD_DAT	GPIO_38
#endif

#endif // USE_MACROS_FOR_IO

// macros, because onewire code has always used macros in the past  -pgf
#define read_CHRG_DQ(void)	( IO_ACTIVE_HIGH(GPIO_06) )
#define read_DQ(void)	read_CHRG_DQ()
#define DQ_DRIVELOW		output_enable_CHRG_DQ()
#define DQ_RELEASE		output_disable_CHRG_DQ()
#define DQ_LOW			( !read_CHRG_DQ() )
#define DQ_HIGH			( read_CHRG_DQ() )

#endif // IO3731_H
